const cloud = require('@cloudbase/node-sdk')

// 初始化云开发实例
const app = cloud.init({
    env: cloud.SYMBOL_CURRENT_ENV
})

// 获取数据库引用
const db = app.database()
const collection = db.collection('resume_templates')

/**
 * resume_templates CRUD 云函数
 * @param {Object} event - 云函数参数
 * @param {Object} context - 云函数上下文
 */
exports.main = async (event, context) => {
    const { action, data } = event

    try {
        // 操作日志
        console.log('resume-templates-crud 调用:', { action, data })

        switch (action) {
            case 'create':
                return await createTemplate(data)
            case 'read':
                return await getTemplate(data)
            case 'update':
                return await updateTemplate(data)
            case 'delete':
                return await deleteTemplate(data)
            case 'list':
                return await listTemplates(data)
            default:
                throw new Error('无效的操作类型')
        }
    } catch (error) {
        console.error('resume-templates-crud 错误:', error)
        return {
            code: -1,
            message: error.message,
            data: null
        }
    }
}

// 创建简历模板
async function createTemplate(data) {
    const { title, fileId, fileIdPdf, imgPreview, tags, enable } = data

    if (!title || (!fileId && !fileIdPdf)) {
        throw new Error('标题和至少一种文件格式(Word或PDF)为必填项')
    }

    const result = await collection.add({
        id: data.id || '',
        title,
        fileid: fileId || '',
        fileidPdf: fileIdPdf || '',
        imgPreview: imgPreview || '',
        imgFileId: data.imgFileId || '',
        tags: tags || '',
        enable: enable !== undefined ? enable : true, // 默认启用
        createdAt: new Date(),
        updatedAt: new Date()
    })

    return {
        code: 0,
        message: '创建成功',
        data: result
    }
}

// 获取单个模板
async function getTemplate(data) {
    const { id } = data

    if (!id) {
        throw new Error('ID为必填项')
    }

    const result = await collection.doc(id).get()

    if (!result.data || result.data.length === 0) {
        throw new Error('模板不存在')
    }

    // 转换字段名以匹配前端期望
    const templateData = result.data[0];
    if (templateData) {
        templateData.fileId = templateData.fileid;
        templateData.fileIdPdf = templateData.fileidPdf;
    }

    return {
        code: 0,
        message: '查询成功',
        data: templateData
    }
}

// 更新模板
async function updateTemplate(data) {
    const { _id, id, title, fileId, fileIdPdf, imgPreview, tags, imgFileId, enable } = data

    if (!_id) {
        throw new Error('ID为必填项')
    }

    const updateData = {
        updatedAt: new Date()
    }

    if (title) updateData.title = title
    if (fileId) updateData.fileid = fileId
    if (fileIdPdf !== undefined) updateData.fileidPdf = fileIdPdf
    if (imgPreview !== undefined) updateData.imgPreview = imgPreview
    if (imgFileId !== undefined) updateData.imgFileId = imgFileId
    if (tags !== undefined) updateData.tags = tags
    if (enable !== undefined) updateData.enable = enable

    const result = await collection.doc(_id).update(updateData)

    return {
        code: 0,
        message: '更新成功',
        data: result
    }
}

// 删除模板
async function deleteTemplate(data) {
    const { _id } = data

    if (!_id) {
        throw new Error('ID为必填项')
    }

    // 使用 _id 或 id 作为唯一标识符
    const result = await collection.doc(_id).remove()

    return {
        code: 0,
        message: '删除成功',
        data: result
    }
}

// 获取模板列表
async function listTemplates(data) {
    const { page = 1, pageSize = 10, tags, title, enableStatus, id } = data

    // 构建查询条件
    let queryCondition = {}

    // 按ID精确查询
    if (id) {
        queryCondition.id = id
    }

    // 按标题模糊查询
    if (title) {
        queryCondition.title = db.RegExp({
            regexp: title,
            options: 'i'
        })
    }

    // 按标签模糊查询
    if (tags) {
        queryCondition.tags = db.RegExp({
            regexp: tags,
            options: 'i'
        })
    }

    // 按启用状态筛选
    if (enableStatus !== undefined) {
        const cmd = db.command
        if (enableStatus === 'enabled') {
            // 构建启用状态的查询条件
            const enabledCondition = cmd.or([
                { enable: true },
                { enable: cmd.exists(false) }
            ])

            // 如果已有其他条件，需要使用 command.and 组合
            if (Object.keys(queryCondition).length > 0) {
                const originalCondition = { ...queryCondition }
                queryCondition = {}

                // 使用 and 组合原条件和启用状态条件
                Object.keys(originalCondition).forEach(key => {
                    queryCondition[key] = originalCondition[key]
                })

                // 添加 OR 条件
                queryCondition = cmd.and([
                    queryCondition,
                    enabledCondition
                ])
            } else {
                // 没有其他条件，直接使用 or 条件
                queryCondition = enabledCondition
            }
        } else if (enableStatus === 'disabled') {
            queryCondition.enable = false
        }
    }

    console.log('查询条件:', JSON.stringify(queryCondition))

    // 创建查询对象
    const query = collection.where(queryCondition)

    const result = await query
        .orderBy('createdAt', 'desc')
        .skip((page - 1) * pageSize)
        .limit(pageSize)
        .get()

    const countResult = await query.count()

    // 转换字段名以匹配前端期望
    const templates = result.data.map(item => {
        return {
            ...item,
            fileId: item.fileid,
            fileIdPdf: item.fileidPdf
        };
    });

    return {
        code: 0,
        message: '查询成功',
        data: {
            list: templates,
            total: countResult.total,
            page,
            pageSize
        }
    }
} 